//package kt.flows
//
//import kotlinx.coroutines.*
//import kotlinx.coroutines.channels.actor
//import kotlinx.coroutines.sync.Mutex
//import kotlinx.coroutines.sync.withLock
//import java.util.concurrent.atomic.AtomicInteger
//import kotlin.system.measureTimeMillis
//
//
///**
// * 共享的可变状态&并发
// * 1，正常情况下，在 100 个协程下进行 1000次共享数据的操作，会发送并发错误
// * [massiveRunDemo]
// *
// * 2，线程安全的数据结构
// * [massiveSafeRunDemo]
// *
// * 3, 状态更新类业务逻辑中大部分都限制在单线中
// * [singleThreadOperateDemo]
// *
// *
// * 4,互斥
// * val mutex = Mutex()
// * mutex.withLock { counter ++ }
// * [exclusionDemo]
// *
// *
// */
//
////sampleStart
//@Volatile
//var counter = 0
//
//var counterSafe = AtomicInteger()
//
//fun main() {
////    massiveRunDemo()
////    massiveSafeRunDemo()
////    singleThreadOperateDemo()
//    exclusionDemo()
//}
//
//
//
//
////--------------------------------------------
//
//sealed class CounterMsg
//object IncCounter : CounterMsg()
//
//class GetCounter(val response : CompletableDeferred<Int>) : CounterMsg()
//
//// 这个函数启动一个新的计数器 actor
//fun CoroutineScope.counterActor() = actor<CounterMsg> {
//    var counter = 0 // actor 状态
//    for (msg in channel) { // 即将到来消息的迭代器
//        when (msg) {
//            is IncCounter -> counter++
//            is GetCounter -> msg.response.complete(counter)
//            else -> {}
//        }
//    }
//}
//
//
//fun actorChannelResponseDemo(){
//    runBlocking {
//
//        val counter = counterActor() // 创建该 actor
//        withContext(Dispatchers.Default) {
//            massiveRun {
//                counter.send(IncCounter)
//            }
//        }
//
//        // 发送一条消息以用来从一个 actor 中获取计数值
//        val response = CompletableDeferred<Int>()
//
//        counter.send(GetCounter(response))
//        println("Counter = ${response.await()}")
//        counter.close() // 关闭该actor
//
//    }
//
//}
//
//
//
//
//
//
////-----------------互斥-------------------------
//val mutex = Mutex()
//
//fun exclusionDemo() {
//    runBlocking {
//        withContext(Dispatchers.Default){
//            massiveRun {
//                mutex.withLock {
//                    counter ++
//                }
//            }
//        }
//        println("counter = $counter")
//
//    }
//}
///*
//            Completed 100000 actions in 106 ms
//            counter = 100000
// */
//
//
//
////------------------------------------------
//
//val conterContext = newSingleThreadContext("newContext")
//
//fun singleThreadOperateDemo() {
//    runBlocking {
//        withContext(conterContext){
//            massiveRun {
//                counter ++
//            }
//        }
//        println("counter = $counter")
//    }
//}
///*
//            Completed 100000 actions in 15 ms
//            counter = 100000
// */
//
////------------------------------------------
//
//fun massiveSafeRunDemo() {
//    runBlocking {
//        withContext(Dispatchers.Default) {
//            massiveRun {
//                counterSafe.incrementAndGet()
//            }
//        }
//        println("counterSafe = $counterSafe")
//
//    }
//}
//
///*
//                Completed 100000 actions in 12 ms
//                counterSafe = 100000
// */
//
//
////------------------------------------------
//
//fun massiveRunDemo() {
//    runBlocking {
//        withContext(Dispatchers.Default) {
//            massiveRun {
//                counter++
//            }
//        }
//        println("Counter = $counter")
//
//    }
//}
//
//suspend fun massiveRun(action: suspend () -> Unit) {
//    val n = 100  // 启动的协程数量
//    val k = 1000 // 每个协程重复执行同一动作的次数
//
//    // 如果不发生并发错误结果 为 n * k  = 1000 * 100
//    val time = measureTimeMillis {
//        coroutineScope { // 协程的作用域
//
//            repeat(n) {
//                launch {
//                    repeat(k) { action() }
//                }
//            }
//
//        }
//    }
//
//    println("Completed ${n * k} actions in $time ms")
//}
//
//
//
//
//
//
//
//
//
//fun demo() {
//    runBlocking {
//
//    }
//}